const _ = require('lodash');
const BigNumber = require('bignumber.js');
module.exports = class extends think.Model {
  /**
   * 生成订单的编号order_sn
   * @returns {string}
   */
  generateOrderNumber() {
    const date = new Date();
    return date.getFullYear() + _.padStart(date.getMonth(), 2, '0') + _.padStart(date.getDay(), 2, '0') + _.padStart(date.getHours(), 2, '0') + _.padStart(date.getMinutes(), 2, '0') + _.padStart(date.getSeconds(), 2, '0') + _.random(100000, 999999);
  }

  /**
   * 获取订单可操作的选项
   * @param orderId
   * @returns {Promise.<{cancel: boolean, delete: boolean, pay: boolean, comment: boolean, delivery: boolean, confirm: boolean, return: boolean}>}
   */
  async getOrderHandleOption(orderId) {
    const handleOption = {
      cancel: false, // 取消操作
      delete: false, // 删除操作
      pay: false, // 支付操作
      delivery: false, // 确认收货操作
      confirm: false, // 完成订单操作
      return: false, // 退换货操作
      buy: false, // 再次购买
      remind: false // 提醒发货
    };

    const orderInfo = await this.where({id: orderId}).find();

    // 订单流程：下单成功－》支付订单－》发货－》收货－》评论
    // 订单相关状态字段设计，采用单个字段表示全部的订单状态
    // 1xx表示订单取消和删除等状态 0订单创建成功等待付款，101订单已取消，102订单已删除
    // 2xx表示订单支付状态,201订单已付款，等待发货
    // 3xx表示订单物流相关状态,300订单已发货，301用户确认收货
    // 4xx表示订单退换货相关的状态,401没有发货，退款402,已收货，退款退货
    // 如果订单已经取消或是已完成，则可删除和再次购买
    // if (orderInfo.order_status === 30) {
    //   handleOption.delete = true;
    //   handleOption.buy = true;
    // }

    // 如果订单没有被取消，且没有支付，则可支付，可取消
    if (orderInfo.status === 0 && orderInfo.pay_status === 0) {
      handleOption.cancel = true;
      handleOption.pay = true;
    }

    // 如果订单已付款，没有发货，则可退款操作
    if (orderInfo.status === 10) {
      handleOption.return = true;
      handleOption.remind = true;
    }

    // 如果订单已经发货，没有收货，则可收货操作和退款、退货操作
    if (orderInfo.status === 20) {
      // handleOption.cancel = true;
      // handleOption.pay = true;
      // handleOption.return = true;
    }

    // 如果订单已经支付，且已经收货，则可完成交易、评论和再次购买
    if (orderInfo.status === 30) {
      handleOption.delete = true;
      handleOption.buy = true;
    }

    return handleOption;
  }

  async getOrderStatusText(orderStatus) {
    let statusText = '未付款';
    switch (orderStatus) {
      case -1:
        statusText = '已取消';
        break;
      case 0:
        statusText = '未付款';
        break;
      case 10:
        statusText = '已付款，等待商家确认';
        break;
      case 15:
        statusText = '已付款，商家接单';
        break;
      case 20:
        statusText = '已付款，已发货，待确认';
        break;
      case 30:
        statusText = '已付款，已发货，已送达';
        break;
      case 40:
        statusText = '已付款，申请取消';
        break;
      case 50:
        statusText = '已付款，申请取消拒绝';
        break;
      case 60:
        statusText = '已付款，申请取消同意';
        break;
    }

    return statusText;
  }

  async getOrderPayText(orderId) {
    const orderInfo = await this.where({id: orderId}).find();
    let statusText = '未付款';
    switch (orderInfo.pay_status) {
      case 0:
        statusText = '未付款';
        break;
      case 2:
        statusText = '微信付款';
        break;
      case 3:
        statusText = '余额付款';
        break;
    }
    return statusText;
  }

  /**
   * 更新用户积分
   * @param orderId
   * @returns {Promise.<boolean>}
   */
  async updateUserScore(order) {
    const orders = await this.model('order_sku').where({order_id: order.id}).select();
    let score = 0;
    for (const item of orders) {
      if (item.score) {
        score += item.score;
      }
    }
    if (score > 0) {
      const user = await this.model('user').where({id: order.user_id}).find();
      await this.model('user').where({id: order.user_id}).increment({score: score});
      this.model('user_score').add({
        score: score,
        user_id: order.user_id,
        nickname: user.nickname,
        money: order.actual_price,
        order_id: order.user_id
      });
    }
  }

  /**
   * 更新代理收益
   * @param orderId
   * @returns {Promise.<boolean>}
   */
  async updateAgentBalance(order) {
    if (!order.agent_id) {
      return;
    }
    const agentUser = await this.model('user_agent').where({user_id: order.agent_id}).find();
    const set = await this.model('agent_set').where({type: 1}).find();

    if (think.isEmpty(agentUser) || think.isEmpty(set)) {
      return;
    }
    const addMoney = (Number(order.actual_price) * set.value).toFixed(2);
    const money = new BigNumber(agentUser.totle_balance).plus(new BigNumber(order.actual_price).multipliedBy(new BigNumber(set.value))).toFixed(2).toString();
    // const money = new BigNumber(agentUser.totle_balance).plus(new BigNumber(order.actual_price)*set.value).toString()
    await this.model('user_agent').where({user_id: order.agent_id}).update({totle_balance: money});
    await this.model('agent_log').add({
      agent_id: order.agent_id,
      money: addMoney,
      order_id: order.id,
      nickname: agentUser.nickname
    });
  }

  /**
   * 更改订单支付状态
   * @param orderId
   * @param payStatus
   * @returns {Promise.<boolean>}
   */
  async updatePayStatus(orderId, payStatus = 0) {
    return this.where({id: orderId}).limit(1).update({
      pay_status: parseInt(payStatus),
      status: 10
    });
  }

  /**
   * 根据订单编号查找订单信息
   * @param orderSn
   * @returns {Promise.<Promise|Promise<any>|T|*>}
   */
  async getOrderByOrderSn(orderSn) {
    if (think.isEmpty(orderSn)) {
      return {};
    }
    return this.where({order_no: orderSn}).find();
  }
  floatFormatter(f, n) {
    var m = Math.pow(10, n);
    return parseInt(f * m, 10) / m;
  }
};
